InterBase: What Sets It Apart - by Borland Developer Support Staff InterBase:무엇이 Borland 개발자 지원 스태프에 의하여 그것을 떼어 둔다. Abstract:The most significant difference between InterBase and other database servers is its multi-generational architecture. InterBase와 다른 데이터베이스 서버 사이의 Abstract:The 가장 중요한 차이는 건축 그것의 generational 멀티이다. As you rush headlong into the world of Client/Server computing one of the first things you have to do is select a database server. The architectures of database servers vary widely and as a result their behavior in a given situation also varies widely. That means that to select the right server for your application you must understand two things. 당신이 꺼꾸로 성급하게 당신이 해야 하는 맨 먼저 중의 하나가 있는 것을 산출하고 있는 고객/서버의 세계를 할 때 데이터베이스 서버를 선택해라.데이터베이스 서버의 건축이 널리 달라 지고 그 결과 또한 주어진 상황의 그들의 행동은 널리 달라 진다.그것은 당신의 응용을 위한 옳은 서버를 선택하기 위해 당신이 2 일을 이해해야 하는 것을 의미한다. How data will be accessed and modified in your application. 어떻게 접근할 것이고 데이터가 당신의 응용에(서)부분 수정될 것이다. How the server will behave in each data access or update situation. 어떻게 서버는 각 데이터 액세스나 업데이트 상황에(서)행동할 것이다. The most significant difference between Interbase and other database servers is its multi-generational architecture. Multi-generational architecture is also called versioning architecture and to understand how it is different you need to explore the different methods of controlling concurrent access to data by many users. Interbase와 다른 데이터베이스 서버 사이의 가장 중요한 차이는 건축 그것의 generational 멀티이다.멀티 generational 건축이 또한 불리운 versioning 건축이고 어떻게 그것이 다르다는 것을 알기 위해 당신은 많은 사용자에 의하여 데이터에의 동시 액세스를 컨트롤하는 다른 방법을 조사해야 한다. Locking Schemes 계획을 잠그기 The oldest and most common method of controlling concurrent access to data by several users is locking. When one user locks an object in a database he or she restricts the ability of other users to access that object. How much a lock affects concurrency depends on the granularity of the lock. For example, a lock placed on an entire table will restrict other users access to all of the rows in the table. Therefore, a table level lock has very low granularity. A lock placed on a single page in a table limits access to all of the rows on that page. A page level lock is more granular than a table level lock. By contrast, a lock placed on a single row is very granular and provides the minimum restriction to concurrent data access. 여러 사용자에 의하여 데이터에의 동시 액세스를 컨트롤하는 가장 오래되고 가장 공통적인 방법은 잠기고 있다.하나 사용자가 물건을 데이터베이스에 넣고 잠글 때 그나 그녀는 그 물건에 접근할 다른 사용자의 능력을 제한한다.얼마 자물쇠 병행성 감정은 자물쇠의 알갱이 모양에 의존한다.예를 들면 전체 테이블에 둬 진 자물쇠가 사용자 테이블의 모든 줄에의 다른 액세스를 제한할 것이다.따라서 테이블 균일한 자물쇠는 매우 낮은 알갱이 모양을 가지고 있다.테이블에(서)단하나의 페이지에 둬 진 자물쇠가 그 페이지 위의 모든 줄에 대한 액세스를 제한한다.페이지 균일한 자물쇠는 테이블이 자물쇠를 고르게 하는 것보다 더 알갱이 모양의다.대조적으로 단하나의 줄에 둬 진 자물쇠가 매우 알갱이 모양의고 동시 데이터 액세스에(게)에 최소 제한을 제공한다. Database servers support either row or page level locking. The problem with page level locks is easy to see if you consider an example. Suppose the size of a page is 2k (2048 bytes) and the size of a row is 100 bytes. Then each page can hold 20 rows and each time a page is locked access is restricted to all 20 rows. With row level locking only a single row would be locked and other users would be free to access other records on the page so row level locking provides better concurrency. 데이터베이스 서버는 잠기면서 또한 줄이나 페이지 레벨을 지지한다.페이지 레벨을 가지고 문제 자물쇠는 만약 당신이 예를 고려한다면 보기에 쉽다.페이지의 사이즈가 2k(바이트 2048 편)이고 줄의 사이즈가 바이트 100 편이라고 가정해라.그때 각 페이지가 20 줄을 잡을 수 있고 페이지가 잠길 때마다 액세스는 모든 20 줄에(게)제한된다.줄 레벨을 가지고 단하나의 줄만을 잠그는 것이 잠겨 질 것이고 다른 사용자는 자유롭게 페이지 위의 다른 기록에 접근할 수 있을 것이다 그래서 줄 잠기고 있는 레벨이 더 좋은 병행성을 제공한다. If you come from a desktop database background you are probably most familiar with a scheme called pessimistic locking. Pessimistic locking is so named because it assumes that the probability is high that another user will try to modify the same object in the database that you are changing. In a pessimistic locking environment the object you wish to change is locked before you begin changing it and remains locked until you commit your change. The advantage of pessimistic locking is that you are guaranteed that you will be able to post the changed row. 만약 당신이 데스크탑 데이터베이스 백그라운드에서 온다면 당신은 아마 비관적인 것이라고 불리는 잠기고 있는 계획을 가장 잘 알고 있일 것이다.그것이 개연성이 다른 사용자가 높이 그것을 시도할 것 똑같은 물건을 부분 수정하기 위해 당신이 바꾸고 있는 데이터베이스에 있다고 생각하기 때문에 비관적이게 잠기는 것이 그렇게이라고 명명된다.당신이 그것을 바꾸기 시작하고 당신이 당신의 체인지를 범할 때까지 남아 있는 것이 잠기기 전에 비관적인 잠기고 있는 환경에(서)당신이 바꾸고 싶은 물건이 잠긴다.비관적이게 잠기는 이점은 당신에게 당신이 바뀐 줄을 알릴 수 있을 것을 보증하는 것이다. Suppose you need to change a customer’s address. Using pessimistic locking you would first lock the customer information at either the page or row level. You can then read the customer’s record, change it and be guaranteed that you can write your changes to the database. Once you commit your changes your lock is released and others are free to change the customer’s record. Locks can persist for a long time when pessimistic locking is used. You could begin a change then go to lunch and not commit the change and release the lock until you return. Clearly you want to use locks with high granularity if you are going to use pessimistic locking in a multi-user environment. If you must lock an entire page of customer records while you are changing a single row no other user will be able to change any other customer record on that page. Row level locks are best when pessimistic locking is used because they impose the least restriction on access by other users. Page level locks are much less satisfactory because they restrict access to many rows as long as they persist. 당신이 고객의 주소를 바꾸어야 한다고 가정해라.처음으로 비관적이게 당신을 잠그는 것이 또한 페이지나 줄 레벨에(서)고객 정보를 잠글 것인 사용하기.그때 당신이 고객의 기록을 읽을 수 있다.그것을 바꿀 수 있다.당신이 데이터베이스에 대한 당신의 체인지를 쓸 수 있다고 보장해 질 수 있다.일단 당신이 당신의 체인지를 범하면 당신의 자물쇠가 발표되고 다른 사람은 자유롭게 고객의 기록을 바꿀 수 있다.비관적이게 잠기는 것이 사용될 때 자물쇠는 오랫동안 계속될 수 있다.당신은 당신이 돌아오는 그때가 점심을 먹고 체인지를 범하지 않고 자물쇠를 발표하지 않으러 가는 체인지를 시작할 수 있었다.만약 당신이 사용 비관적이게 multi-user 환경을 잠그는 것에 가고 있는다면 명확하게 당신은 높은 알갱이 모양을 가지고 자물쇠를 사용하고 싶다.만약 당신이 단하나의 줄을 바꾸고 있는 동안 당신이 고객 기록의 전체 페이지를 잠가야 한다면 다른 사용자는 그 페이지 위의 다른 어떤 고객 기록을 바꿀 수 있을 것이 아니다.그들이 최소 액세스에 제약을 가하기 때문에 비관적이게 잠기는 것이 다른 사용자에 의하여 사용될 때 균일한 자물쇠가 가장 좋 배를 저어라.그들이 계속된 한 그들이 많은 줄에 대한 액세스를 제한하기 때문에 Page 균일한 자물쇠는 much less 만족스럽다. The most common locking scheme found in database servers is optimistic locking. The locking mechanism is optimistic in that it assumes that it is very unlikely that another user will try to change the same row that you are changing. An optimistic lock is not placed until you try to commit your changes. To understand optimistic locking consider two users, John and Jane, trying to change a customer’s record. First John reads the record and begins to make changes. Next Jane reads the record and begins to make changes. This is possible because in the optimistic locking scheme no lock is placed when a user reads a record and begins changing it. Next John completes his changes and attempts to commit them. At this point the database locks the record, commits the change and releases the lock. When Jane tries to commit her change the software detects that the record has been changed since Jane read it and her change is rejected. Jane must now re-read the record and begin again. 가장 공통적이게 데이터베이스 서버에서 발견해 진 계획을 잠그는 것은 잠기면서 낙천적이다.잠기고 있는 장치는 그것에(서)그것이 그것이 다른 사용자가 당신이 바꾸고 있는 똑같은 줄을 바꾸려고 노력할 것 매우 있을 법하지 않는다고 생각하는 낙천적이다.당신이 당신의 체인지를 범하려고 노력할 때까지 낙천적인 자물쇠를 두지 않는다.고객의 기록을 바꾸려고 노력하면서 낙천적이게 잠기는 것을 이해하기 위해 사용자와 존과 제인 2 명을 고려해라.첫째 존이 기록을 읽고 바꾸기 시작한다.다음 제인이 기록을 읽고 바꾸기 시작한다.사용자가 기록을 읽고 그것을 바꾸기 시작할 때 낙천적인 잠기고 있는 계획에(서)자물쇠를 두지 않기 때문에 이것은 가능하다.다음 존이 그의 체인지를 완료하고 그들을 범하려고 한다.이 시점에서 데이터베이스가 기록을 잠근다.체인지를 범한다.자물쇠를 발표한다.제인이 그녀의 체인지를 범하려고 노력할 때 소프트웨어는 제인이 그것을 읽었고 그녀의 체인지를 거부하는 이래로 기록이 바뀐 것을 탐지한다.지금 기록 re-read이야 하고 제인은 다시 시작해야 한다. Optimistic locking has a clear advantage in that locks are only held for a very brief period while the data is actually being updated. That means that with an optimistic locking scheme you can achieve adequate concurrency with less lock granularity. Therefore, databases that use optimistic locking may lock at the page level and not at the row level. On the other hand, optimistic locking does not fare well in an environment where there is a high probability that two users will try to update the same row at the same time. 낙천적이게 잠기는 것은 실제로 데이터가 업데이트된 동안 매우 간략한 시기 동안 그것에(서)단지 자물쇠를 잡는 명확한 이점을 가지고 있다.그것은 낙천적인 잠기고 있는 계획을 가지고 당신이 더 적은 자물쇠 알갱이 모양을 가지고 알맞은 병행성을 얻을 수 있는 것을 의미한다.따라서 사용 낙천적이게 잠기는 것이 페이지 레벨에(서),줄에(서)잠그지 않을 수 있는 데이터베이스는 수평으로 된다.2 사용자가 동시에 똑같은 줄을 업데이트하려고 노력하는 높은 개연성이 있는 곳에 다른 한편으로는 낙천적이게 잠기는 것은 잘 환경에(서)해나가지 않는다. From the database vendor’s point of view page level locking is advantageous in that fewer locks must be placed, particularly during batch operations that affect many rows. This means that the resource requirements of the lock manager module in the database management system are lower and this can help performance of the database server. However, users are invariably the slowest part of any database application so you will usually get better overall performance in an environment where one user cannot block another. 뷰 페이지 레벨의 데이터베이스 판매자의 포인트로부터 잠기는 것은 특히 많은 줄에 영향을 미치는 묶음 작동 동안 놓여야 그렇게 더 적은 자물쇠에(서)유익하다.이것이 데이터베이스 경영 시스템의 자물쇠 매니저 모듈의 리소스 요건이 더 낮은 것을 의미하고 이것은 데이터베이스 서버의 퍼포먼스를 도울 수 있다.그러나 사용자는 변화하지 않고 모든 데이터베이스 응용의 가장 느린 부분이다 그래서 하나 사용자가 다른 하나를 막을 수 없는 곳에 보통은 당신이 환경의 더 좋은 전체적인 퍼포먼스를 받을 것이다. Understanding how your database manages locks can be critically important. Consider an orders table. New records are being added continuously as new orders are received. Because the order data does not include a field or fields which would form a natural primary key you decide to use an artificially generated order number as a surrogate key. Order numbers will be assigned sequentially as orders are received. Since your application will frequently need to select groups of orders you create a clustered index on the order number column. A clustered index provides superior performance when retrieving adjacent records because the records are physically stored in key order within the database pages. 어떻게 당신의 데이터베이스가 자물쇠를 관리한다는 것을 아는 것은 비판적으로 중요할 수 있다.오더 테이블을 고려해라.새로운 오더를 받을 때 계속하여 새로운 기록을 더한다.오더 데이터가 필드를 포함하지 않거나 결정한 필드가 자연스러운 기본키를 만들기 때문에 당신은 대리인의 키로서 인위적으로 만들어 내 진 오더 숫자를 사용하기로 결정한다.오더를 받을 때 오더 숫자가 연속적으로 부여될 것이다.빈번하게 당신의 응용이 오더 그룹을 선택해야 할 것인 이래로 당신은 오더 숫자 컬럼 위의 모인 인덱스를 만든다.인접한 기록을 되찾을 때 육체적으로 기록이 데이터베이스 페이지 안에서 주요 오더에 저장해 지기 때문에 모인 인덱스가 상위 퍼포먼스를 제공한다. Unfortunately this design is likely to produce poor performance if the database uses page level locking. Since sequential adjacent keys are being assigned and a clustered index is being used each new record that is added will probably be placed on the same page as the preceding record. Since the database locks at the page level two users cannot add new orders to the same page at the same time. Each new order must wait until the page lock placed by the preceding order is released. In this case you would get much better performance by assigning the keys randomly to reduce the chance that successive records will be added to the same page. 만약 데이터베이스가 잠기면서 페이지 레벨을 사용한다면 불행히도 이 디자인은 보잘것 없는은 퍼포먼스를 만들 것 같다.계속적인 인접한 키가 재산권을 양도해 지고 모인 인덱스가 사용된 이래로 아마 더하는 각 새로운 기록이 선행하고 있는 기록과 같은 페이지에 둬 질 것이다.데이터베이스가 균일한 2 페이지에(서)잠기는 이래로 사용자는 동시에 똑같은 페이지에 새로운 오더를 추가할 수 없다.각 새로운 오더는 선행하고 있는 오더에 의하여 놓인 페이지 자물쇠가 발표될 때까지 기다려야 한다.이 경우에는 당신은 마구잡이로 키에게 연속한 기록이 똑같은 페이지에 추가된 찬스를 조정하도록 지시함으로써 훨씬 더 좋은 퍼포먼스를 받을 것이다. Transactions 거래 Another requirement of database servers is the ability to group changes to the database into transactions. Update transactions consist of one or more changes to one or more tables in the database which must be treated as a single unit so that either all of the changes that comprise the transaction take place or none of the changes take place. 데이터베이스 서버의 다른 요건은 데이터베이스에 대한 체인지를 거래별로 분류할 능력이다.또한 거래로 구성된 모든 체인지가 일어나거나 어떤 체인지도 일어나지 않도록 업데이트 거래는 단하나의 유닛 취급해 져야 하는 데이터베이스의 하나 이상 테이블에 대한 하나 이상 체인지로 구성된다. Transaction processing takes place in three steps. First you tell the database software that you wish to begin a transaction. This informs the database system that all changes until further notice are to be treated as a single unit. Next, the changes are actually made to the tables in the database. Finally, you notify the database system that you wish to either commit or rollback the transaction. If you commit the transaction then the changes become permanent. If you rollback the transaction all of the changes are undone. 거래 프로세싱은 세 스텝에서 열린다.처음으로 당신은 데이터베이스 소프트웨어에게 당신이 거래를 시작하고 싶다고 말한다.이것은 추후 통지가 있을 때까지 모든 체인지는 단하나의 유닛 취급해 지는 것이라고 데이터베이스 시스템에게 알린다.데이터베이스의 테이블에(게)다음에 실제로 체인지를 한다.마침내 당신은 거래 당신이 또한 범하기를 바라는 데이터베이스 시스템이나 롤백정책을 알린다.만약 당신이 거래를 완료한다면 그 경우에는 체인지는 영구적이게 된다.모든 체인지가 있는 거래 만약 당신 롤백정책 원상태로 돌려 지는 것. Transaction processing is vital to ensure the logical integrity of the database. Consider the case where John transfers $100 from his savings account to his checking account. This transaction would proceed as follows. 거래 프로세싱은 데이터베이스의 논리적인 완전성을 확실하게 하기 위해 활력 있다.존이 $100을 그의 예금 계좌에서 그의 어카운트를 체크하는 것으로 옮기는 곳에 케이스를 고려해라.이 거래는 다음과 같이 계속 나아갈 것이다. Start a new transaction. 새로운 거래를 시작해라. Update the balance in the savings account to show a withdrawal of $100. $100의 철회를 보이기 위해 예금 계좌의 밸런스를 업데이트해라. Update the balance in the checking account to show an increase of $100. $100의 증가를 보이기 위해 은행 당좌 예금의 밸런스를 업데이트해라. Either commit or rollback the transaction. 또한 그렇지 않으면 롤백정책 거래 범하여라. Suppose the system crashes after step two but before step 3. Without transaction control John would have lost $100. With transaction control, when the system is restarted the database software will automatically rollback any transactions that had not been committed at the time of the crash. This guarantees that the database will be left in a consistent state. 시스템이 2 단계 후에 그러나 3 단계 앞에서 부서진다고 가정해라.거래 컨트롤 없이 존은 잃어버린 $100을 가지고 있을 것이다.시스템이 재개될 때 거래 컨트롤을 가지고 데이터베이스 소프트웨어는 충돌의 시간에 committed이지 않은 모든 거래 자동적으로 롤백정책 결정한다.이것은 데이터베이스가 일관된 스테이트에 남겨 두어 질 것이라고 보장한다. You also need transaction control for read transactions that will read more than a single record to ensure that the read returns a consistent view of the data. This requirement is described in more detail in the next section. 또한 당신은 단하나의 기록보다 그 이상을 읽을 읽기 거래가 읽기가 데이터의 일관된 뷰를 되돌려주라는 것을 확실하게 하는 것 거래 컨트롤이 필요한다.다음 섹션의 더 많은 상세히 이 요건을 묘사한다. Transaction Isolation 거래 고립 Transaction isolation governs how transactions that are executing simultaneously interact with each other. Many of today’s database servers were originally designed to process very short update transactions intermixed with single row reads. The perfect example is a bank automated teller (ATM). An ATM reads the balance in a single account or updates the balance in one or more accounts. In this environment, transactions are very short and reads involve a single row at a time so transaction isolation is not a serious concern. However, many of today’s database applications do not fit that model. 거래 고립은 어떻게 동시에 수행하고 있는 거래가 서로와 서로 영향을 미치게 다스린다.원래는 오늘의 데이터베이스 다수의 서버가 단하나의 줄 읽기와 섞어 진 매우 간결한 업데이트 거래를 처리하도록 만들어졌다.완벽한 예는 뱅크 자동화된 화자(비동기 전송모드)이다.비동기 전송모드가 단하나의 어카운트의 밸런스를 읽거나 하나 이상 어카운트의 밸런스를 업데이트한다.거래가 매우 짧고 읽기는 한번에 단하나의 줄을 이 환경에 끌어넣는다 그래서 거래 고립이 중대한 관심이 아니다.그러나 오늘의 데이터베이스 다수의 응용 프로그램은 그 모델에게 맞지 않는다. Short update transactions are still the norm but the advent of executive information systems has introduced long running read transactions that span whole tables and sometimes entire databases. To understand the problem with long read transactions consider the following scenario. 간결한 업데이트 거래가 아직도 표준이지만 경영 간부 정보 시스템의 출현이 모든 테이블과 때때로 전체 데이터베이스에 이르는 긴 달리고 있는 읽기 거래를 소개했다.긴 읽기를 가지고 문제를 잘 알기 위해 거래는 다음 시나리오를 고려한다. An executive requests the total value of the company’s inventory by warehouse. While the query is scanning the inventory table a user moves a pallet of platinum bars from warehouse A to warehouse B and commits the transaction. It is possible for the query to count the platinum in both warehouse A and warehouse B thus producing an erroneous inventory valuation report. The question then becomes, which updates should a read transaction see and when should it see them? This is what the transaction isolation level controls. There are four isolation levels defined in the SQL 92 standard as follows. 경영 간부가 창고에 의하여 컴퍼니의 품목일람의 전체적인 가치를 부탁한다.질문이 사용자가 움직이는 품목일람 테이블을 살펴보고 있는 동안 백금의 팔레트가 B을 창고에 넣기 위해 A을 창고에서 제외하고 거래를 완료한다.질문이 A 창고와 이렇게 잘못된 품목일람 평가 리포트를 만들고 있는 B 창고 둘 다의 백금을 세는 것은 가능하다.읽기 거래가 어느 업데이트를 보아야 합니까 언제 그것이 보아야 합니까 그때 질문 그들 됩니까?이것은 거래 고립 레벨이 컨트롤하는 것이다.다음과 같이 SQL 기준 92 권에(서)정의한 4 고립 레벨이 있다. Read Uncommitted - this isolation level, sometimes called dirty read, allows any record in the database to be read whether it has been committed or not. 때때로 더러운 읽기라고 불리는 이 고립 레벨이 그것이 committed이었는지 아닌지 읽히기 위해 데이터베이스에(서)모든 기록을 허락하지 저지르지 않게 읽혀라. Read Committed - this level allows read transactions to see only those changes that have been committed. 범하여서 읽어라-이 레벨이 읽기 거래가 committed이었던 그 체인지들만을 보도록 허락해라. Repeatable Read - ensures that if your transaction rereads records that it has read earlier it will find the same values in all of the fields of those records. This does not mean that you will get the same set of records on the second read. For example, if another transaction inserts a record that meets the criteria of the WHERE clause in your select you will see this new record the second time your transaction executes the SELECT. 반복될 수 있는 읽기는 만약 당신의 거래가 그것이 더 일찍 읽은 기록을 다시 읽는다면 그것이 똑같은 가치관을 그 기록들의 모든 필드에서 발견할 것이라는 것을 확실하게 한다.이것은 당신이 읽힌 두 번째 위에서 똑같은 기록 세트를 얻을 것을 의미하지 않는다.만약 다른 거래가 기록을 삽입한다면 예를 들면 그것은 당신이 당신의 거래가 수행하는 두 번째 이 새로운 기록을 볼 것 어디에 조항 당신의 선택해라 선택해라 기준을 만난다. Serializable - ensures that if you issue the same SELECT multiple times during the life of your transaction you will see exactly the same set of records with the same values in every field. It also ensures that there is some serial order of concurrent transactions that will produce the same result as that produced by concurrent execution. Interbase's snapshot transaction isolation level provides the same degree of isolation from changes made by other transactions as serializable. Serializable 만약 당신이 당신의 거래의 생명(삶)동안 똑같은 엄선된 다중 시간을 내린다면 당신이 똑같은 가치관을 가지고 모든 필드에(서)정확하게 똑같은 기록 세트를 볼 것이라는 것을 확실하게 한다.또한 그것은 동시 실행에 의하여 보여 주어 진 그것과 같은 결과를 보여 줄 동시 거래의 몇몇의 연속적인 오더가 있다는 것을 확실하게 한다.Interbase의 스냅사진 거래 고립 레벨은 serializable일 때 다른 거래에 의하여 만들어 진 체인지로부터 고립의 똑같은 정도를 제공한다. In the example above what you need to ensure that your inventory valuation report is accurate is serializable isolation. The problem is the price that you must pay to get serializable isolation in a database that uses locking architecture. With the locking model the only way to ensure that data does not change during a long read transaction is to prevent any updates from taking place until the read transaction ends by locking each record as it is read. In many situations the effect on users of stopping all updates on a large number of rows for the duration of a long read transaction is unacceptable. serializable 고립은 당신이 당신의 품목일람 평가 리포트가 정확하다는 것을 확실하게 해야 하는 것 위에 예에 있다.문제는 당신이 잠기고 있는 건축을 사용하는 데이터베이스의 serializable 고립을 얻는 것 지불해야 하는 가격이다.잠기고 있는 모델을 가지고 데이터가 긴 읽기 거래 동안 변하지 않으라는 것을 확실하게 하기 위한 방법만은 모든 업데이트가 그것을 읽을 때 각 기록을 잠금으로써 읽기 거래 목적까지 일어나지 못하는 것이다.많은 상황에(서)긴 읽기 거래의 지속기간을 위해 많은 줄 위의 모든 업데이트를 멈추는 사용자에 대한 효과는 받아들일 수 없다. Versioning Versioning There is another model for concurrency control called versioning which overcomes the problems that locking model databases have when the environment consists of a mixture of update and long read transactions. This model is called the versioning model and is the model used by Interbase. To understand the basics of the versioning model consider the preceding example. With a versioning database the read transaction to produce the inventory valuation report begins. When the update transaction to move the pallet of platinum from warehouse A to warehouse B is committed a new version of each updated record is created, however, the old version still exists in the database. 환경이 업데이트와 긴 읽기 거래의 혼합으로 구성될 때 잠기고 있는 모델 데이터베이스가 가지고 있는 문제를 극복하는 versioning이라고 불리는 동시 제어를 위한 다른 모델이 있다.versioning 모델이라고 불리고 이 모델은 Interbase에 의하여 사용된 모델이다.이해하기 위해 versioning 모델의 베이직은 선행하고 있는 예를 고려한다.versioning 데이터베이스를 가지고 품목일람 평가 리포트를 만들 읽기 거래는 시작된다.B을 창고에 넣을 A 창고로부터 백금의 팔레트를 움직일 업데이트 거래가 committed일 때 각 업데이트된 기록의 새로운 버전이 만들어 진다.그러나 아직도 오래된 버전은 데이터베이스에(서)존재한다. In a versioning database each transaction is assigned a sequential transaction number. In addition, the database manager maintains an inventory of all active transactions. The transaction inventory pages show whether the transaction is active, committed or rolled back. versioning 데이터베이스에(서)각 거래가 계속적인 거래 숫자를 부여해 진다.게다가 데이터베이스 매니저는 수많은 활발한 거래 가운데에서 품목일람을 유지한다.거래 품목일람 페이지는 거래가 활발하거나 committed이거나 취소하는지 아닌지는지를 보여준다. When an update transaction commits, the database software checks to see if there are transactions with lower transaction numbers that are still active. If so then a new version of the record is created which contains the updated values. Each version also contains the transaction number of the transaction that created it. Note that Interbase does not create a complete copy of the row. Instead it creates a difference record that only contains the fields that were changed. 업데이트 거래가 범할 때 데이터베이스 소프트웨어는 만약 아직도 활발한 거래 작은 수를 가지고 거래가 있는다면을 보는 것 체크한다.그렇다면 그때 기록의 새로운 버전이 어느 것이 업데이트된 가치관을 가지고 있 만들어 진다.또한 각 버전은 그것을 만든 거래의 거래 숫자를 가지고 있다.Interbase이 줄의 완전한 카피를 만들지 않는다는 것을 언급해라.그 대신 그것은 단지 바뀐 필드를 가지고 있는 차이 기록을 만든다. When a read transaction begins it gets the next transaction number and a copy of the transaction inventory pages that show the status of all transactions that have not yet committed. As a read transaction requests each row in a table the database software checks to see if the transaction number for the latest version of the row is greater than the transaction number of the transaction that is requesting the row and if the transaction was committed at the time the read transaction started. If the transaction number of the latest version of the row is greater than the number of the requesting transaction or if the transaction that created the latest version was active when the read transaction started Interbase looks back through the chain of prior versions until it encounters one whose transaction number is less than the transaction number of the transaction trying to read the row and whose transaction status was committed at the time the read transaction started. When the database manager finds the most recent version that meets these criteria it returns that version. The result is serializable transaction isolation without preventing updates during the life of the read transaction. 읽기 거래가 시작될 때 그것은 다음 거래 숫자와 수많은 아직 범하지 않았던 거래 가운데에서 스테이터스를 보이는 거래 품목일람 페이지의 카피를 얻는다.읽기 거래가 테이블의 각 줄을 부탁할 때 데이터베이스 소프트웨어는 만약 줄의 가장 최근의 버전을위한 거래 숫자가 줄을 부탁하고 있는 거래의 거래 숫자 greater than 만약 거래가 읽기 거래가 시작된 시간에 committed이었다면는다면을 보는 것 체크한다.만약 거래 숫자 가장 늦게 버전 있게 더한 숫자 부탁하는 거래 그렇지 않으면 만약 거래 그것 만들어 지 가장 늦게 버전 있는 활발한 언제 읽혀라 거래 Interbase 모습 뒤로 물러나라.데이터베이스 매니저가 이 기준을 만나는 가장 최신 버전을 발견할 때 그것은 그 버전을 되돌려준다.결과는 생명(삶)동안 없이 업데이트를 막고 있는 읽기 거래의 serializable 거래 고립이다. Consider the following example of a row for which four versions exist. 버전 4 권이 존재하는 줄의 다음 예를 고려해라. Tran=100 (status=committed) Tran=100(status=committed) Tran=80 (status=active when read started) Tran=80(읽힐 때 status=active) Tran=60 (status=rolled back) Tran=60(status=rolled 백) Tran=40 (status = committed when read started) Tran=40(읽힐 때 범한 = 스테이터스) Assume that a read transaction with transaction number 90 attempts to read this row. The read transaction will not see the version of the row created by transaction 100 because the update that created this version took place after transaction 90 began. Transaction 90 also will not be able to read the version created by transaction 80 although it has a lower transaction number because transaction 80 has not committed yet. Although the version for transaction 60 still exists on disk transaction 60 has rolled back and rolled back versions are always ignored. Therefore, the version that transaction 90 will read is the version created by transaction 40. 거래 90 번을 가지고 읽기 거래가 이 줄을 읽으려고 한다고 생각해라.거래 90이 시작된 후에 이 버전을 만든 업데이트가 일어나기 때문에 읽기 거래는 거래 100에 의하여 만들어 지는 줄의 버전을 보지 않을 것이다.비록 거래 80이 아직 범하지 않았기 때문에 그것이 거래 작은 수를 가지고 있기는 하지만 또한 거래 90은 거래 80에 의하여 만들어 진 버전을 읽을 수 있지 않을 것이다.비록 아직도 거래 60을위한 버전이 존재하기는 하지만 디스크 거래 위에서 60이 취소했고 언제나 돌돌 만 뒤 버전이 무시 당한다.따라서 그 거래 90이 읽을 것인 버전은 거래 40에 의하여 만들어 진 버전이다. Note in this example that transaction 80 will not be allowed to commit. When transaction 80 attempts to commit the database manager will discover that transaction 100 has committed and transaction 80 will be rolled back. 이 예에서 거래 80이 범하도록 허락 받지 않을 것인 것을 언급해라.거래 80이 범하려고 할 때 데이터베이스 매니저는 거래 100이 범하였고 거래 80이 취소해 질 것임을 알게 될 것이다. How They Compare 어떻게 그들은 비교한다. To get a more complete understanding of how the locking and versioning models compare you need to look at the types of concurrency conflicts that can occur in a multi-user database and how each model behaves in each case. The following examples assume that the locking model uses a shared read lock and an exclusive write lock to implement optimistic locking. Multiple users can place read locks but no user can place a write lock if another user has either a read or write lock. If one user has a write lock another user can neither read or write the row. This is typical of databases that use locking architecture. In the following examples three scenarios are explored. The first is what happens with no concurrency control, the second is what happens using the locking model and the third is what happens with versioning. 잠겨기,versioning 모델이 비교하는 더 완전한 어떻게을 이해하기 위해 당신이 유형의 multi-user 데이터베이스에(서)일어날 수 있는 병행성 대립을 보아야 하고 어떻게 각 모델은 각 케이스에(서)행동한다.다음 예는 잠기고 있는 모델이 자물쇠와 독점 판매가 도구 낙천적이게 잠그는 것에 자물쇠를 쓰는 함께 나눠 진 읽기를 사용한다고 생각한다.만약 다른 사용자가 또한 읽기나 기록 자물쇠를 가지고 있다면 다중 사용자가 읽기 자물쇠를 둘 수 있지만 사용자가 기록 자물쇠를 두지 않을 수 있다.만약 하나 사용자가 기록 자물쇠를 가지고 있다면 다른 사용자가 줄을 읽을 수 있거나 쓸 수 없다.이것은 잠기고 있는 건축을 사용하는 데이터베이스의 전형적이다.다음 예에(서)시나리오 3 권을 탐험한다.첫째가 동시 제어 없이 발생하는 것이다.두 번째가 잠기고 있는 모델을 사용하면서 발생하는 것이다.세번째는 versioning을 가지고 발생하는 것이다. Consider the case where a husband and wife go to two different ATM’s at the same time to withdraw money from their checking account. With no concurrency control the following sequence of events can occur. 남편과 부인이 똑같은 돈을 그들의 어카운트를 체크하는 것에서 삭제할 시간에 2 다른 비동기 전송모드의 것에 가는 곳에 케이스를 고려해라.동시 제어 없이 이벤트의 다음 시퀀스는 일어날 수 있다. John reads the balance of the account which is $1,000.. 존은 $1,000.인 계정 잔액을 읽는다. Jane reads the balance of the account which is still $1,000. 제인은 아직도 $1,000인 계정 잔액을 읽는다. John posts a $700 withdrawal. 존은 $700 철회를 알린다. Jane posts a $500 withdrawal. 제인은 $500 철회를 알린다. At this point the account balance is -$200 and the bank is not happy. This happened because with no concurrency control mechanism John’s update is lost as far as Jane is concerned. She never sees the change in account balance. Under the locking model: 이 시점에서 어카운트 밸런스가 -$200이고 뱅크는 행복하지 않다.병행성 컨트롤 장치를 가지고기 때문에 이것은 제인이 염려스러운 한 존의 업데이트가 잃어버리는 발생하지 않았다.결코 그녀는 어카운트 밸런스에(서)체인지를 보지 않는다.잠기고 있는 모델 아래: John reads the balance of the account causing a read lock. 존은 읽기 자물쇠를 야기하고 있는 계정 잔액을 읽는다. Jane reads the balance of the account causing a read lock. 제인은 읽기 자물쇠를 야기하고 있는 계정 잔액을 읽는다. John posts his withdrawal attempting a write lock which fails due to Jane’s read lock. 존은 제인의 읽기 자물쇠 때문에 실패하는 기록 자물쇠를 시도하고 있는 그의 철회를 알린다. Jane posts her withdrawal attempting a write lock which fails due to John’s read lock. 제인은 존의 읽기 자물쇠 때문에 실패하는 기록 자물쇠를 시도하고 있는 그녀의 철회를 알린다. A deadlock now exists. Hopefully the database software will detect the deadlock and rollback one of the transactions. 지금 교착상태가 존재한다.Hopefully 데이터베이스 소프트웨어는 교착상태와 거래의 롤백정책 하나를 탐지할 것이다. Under the versioning model: versioning 모델 아래: John reads the balance of the account. 존은 계정 잔액을 읽는다. Jane reads the balance of the account 제인은 계정 잔액을 읽는다. John posts his withdrawal which causes a new version with new balance to be written. 존은 새로운 밸런스를 가지고 새로운 버전이 쓰이어 지게 되는 그의 철회를 알린다. Jane posts her withdrawal but is rolled back when the newer version is detected. 더 새로운 버전을 탐지할 때 제인 그녀의 철회를 알리지만 취소해 진다. A different problem occurs if a user rolls back a transaction. 만약 사용자가 거래를 취소한다면 다른 문제가 일어난다. John withdraws money from the account which updates the balance. 존은 돈을 밸런스를 업데이트하는 계좌에서 삭제한다. Jane reads the balance. 제인은 밸런스를 읽는다. John rolls back his transaction before committing. 범하기 전에 존은 그의 거래를 취소한다. Jane has now seen the wrong balance. 지금 제인은 잘못된 밸런스를 보았다. In this case a dependency exists between the two transactions. Jane’s transaction produces the correct results only if John’s transaction commits. This illustrates the danger of reading uncommitted data and shows why most databases do not allow dirty read transaction isolation. Using locking the following occurs. 이 경우에는 의존 상태가 2 거래 사이에(서)존재한다.존의 거래가 범할 경우에만 제인의 거래는 옳은 결과를 보여 준다.이것이 저지르지 않은 데이터를 읽는 위험을 설명하고 고립 왜 대부분의 데이터베이스가 더러운 읽기 거래를 허락하지 않는 것을 보인다.지지자를 잠그는 것이 일어나는 사용하기. John reads the balance which places a read lock. 존은 읽기 자물쇠를 두는 밸런스를 읽는다. John commits his withdrawal which places a write lock during the update. 존은 업데이트 동안 기록 자물쇠를 두는 그의 철회를 범한다. Jane reads the balance which attempts a read lock but must wait due to John’s write lock. 제인 읽기 자물쇠를 시도하는 밸런스를 읽지만 존의 기록 자물쇠 때문에 기다려야 한다. John cancels the transaction before committing. This rolls back and releases the write lock. 범하기 전에 존은 거래를 취소한다.이것이 뒤로 구르고 기록 자물쇠를 발표한다. Jane can now read and get the correct balance. 지금 제인이 옳은 밸런스를 읽을 수 있고 얻을 수 있다. Under versioning: versioning 아래: John withdraws money which updates the balance and creates new uncommitted version. 존은 밸런스를 업데이트하고 새로운 저지르지 않은 버전을 만드는 돈을 찾는다. Jane reads the balance. This does not reflect John’s uncommitted withdrawal. 제인은 밸런스를 읽는다.이것은 존의 저지르지 않은 철회를 반영하지 않는다. John rolls back so the version showing the withdrawal is marked rolled back. 존은 취소한다 그래서 취소해 지는 철회를 보이고 있는 버전에 마크를한다. This illustrates a performance advantage of versioning since Jane does not have to wait to read the balance. 제인이 밸런스를 읽는 것 기다려야 하지 않은 이래로 이것은 versioning의 퍼포먼스 이점을 설명한다. The following is a different example but the same scenario as the example of the platinum moving form one warehouse to another earlier in this article. 지지자는 다른 예 하나가 창고에 넣는 백금 감동적인은 형태의 이 물품의 더 이르 다른 하나에 관한 예로서 그러나 똑같은 시나리오이다. John requests the total of all accounts. 존은 전부 모든 어카운트를 부탁한다. Jane transfers money from savings to checking while John’s transaction is running. 존의 거래가 달리고 있는 동안 제인은 저축으로부터 돈을 체크하는 것으로 옮긴다. John gets the wrong total. 존은 잘못된 토털을 받는다. Here the analysis of the data is inconsistent because the state of the data was not preserved throughout the life of the read transaction. Under locking: 읽기 거래의 생명(삶)을 두루 거쳐 데이터의 스테이트를 보존하지 않기 때문에 여기 데이터의 분석은 엇갈린다.잠기기: John requests total of all accounts thereby placing a read lock. 존은 전부 그 때문에 읽기 자물쇠를 두고 있는 모든 어카운트를 부탁한다. Jane transfers money but cannot place a write lock to commit the transfer due to John’s read lock. Jane must wait until the read transaction finishes. 존의 읽기 자물쇠 때문에 이전을 범하기 위해 제인 돈을 옮기지만 기록 자물쇠를 둘 수 없다.제인은 읽기 거래 마무리까지 기다려야 한다. John gets the right total, releases the read lock and Jane’s transaction proceeds. 존은 옳은 토털,릴리스에게 읽기 자물쇠와 제인의 거래 수익을 가져다 준다. Under versioning: versioning 아래: John requests the total of all of his accounts. 존은 전부 그의 모든 어카운트를 부탁한다. Jane transfers money from savings to checking resulting in new versions which John’s transaction does not see. 제인은 존의 거래가 보지 않게 새로운 버전으로 끝나면서 저축으로부터 돈을 체크하는 것으로 옮긴다. John gets the right total and Jane’s update is not delayed. 존이 옳은 토털을 받고 제인의 업데이트가 늦어 지지 않는다. Another variation of the serializable problem occurs if you need to reread the data in the course of the transaction. For example: 만약 당신이 거래 동안 데이터를 다시 읽어야 한다면 serializable 문제의 다른 변화는 일어난다.예를 들면: Query for all rowss meeting certain criteria. 어떤 기준에게 모든 rowss 미팅에 대해 물어라. Another user inserts a new row that meets the criteria. 다른 사용자는 기준을 만나는 새로운 줄을 삽입한다. Repeat the query and you will get one additional row. The appearance of this phantom row is not consistent within the transaction. 질문을 반복하면 당신은 하나 추가된 줄을 얻을 것이다.이 유령 줄의 출현은 거래 안에서 일관되지 않는다. With a database that uses the locking model the only way to prevent this inconsistency is to read lock the whole table for the duration of the transaction. Thus the sequence of events is: 방해가 되기 위한 유일한 방법 잠기고 있는 모델을 사용하는 데이터베이스를 가지고 이 불일치는 자물쇠 거래의 지속기간에게 모든 테이블을 읽어 주는 것이다.이렇게 이벤트의 시퀀스는 있다: Place a read lock on the table. 읽기 자물쇠를 테이블에 둬라. Query for all records meeting certain criteria. 어떤 기준을 만나고 있는 모든 기록을 위한 질문. Another user attempts to insert a record but is blocked by the table level read lock. 다른 사용자 기록을 삽입하려고 하지만 자물쇠 읽어 준 테이블용 레벨에 의하여 막힌다. Repeat the query and you will get the same results because other users cannot commit changes. 질문을 반복하면 다른 사용자가 체인지를 범할 수 없기 때문에 당신은 똑같은 결과를 얻을 것이다. Under versioning there is no problem because the newly inserted record has a higher transaction number than the read transaction and so it is ignored on the second and subsequent reads that are part of the same transaction. 새로 끼운 기록이 두 번째 다음 읽기 위에서 거래 큰 수를 가지고 있 읽기 거래보다 그래서 그것이 무시 당한다기 때문에 똑같은 거래의 부분인 문제는 그 곳 versioning 아래 없다. So far it looks like the versioning model handles most concurrency conflicts better than the locking model. However, this is not always the case. Consider the following case where John and Jane are both told to make their salaries equal. 너무 far 그것은 versioning 모델이 잠기고 있는 모델보다 더 낫 대부분의 병행성 대립을 다룬 것처럼 본다.그러나 이것은 언제나 케이스가 아닌 것은 아니다.둘 다 존과 제인이 그들의 봉급을 동등하게 만드는 것을 들은 곳에 다음 케이스를 고려해라. John reads John’s salary. 존은 존의 봉급에게 읽어 준다. Jane reads Jane’s salary. 제인은 제인의 봉급에게 읽어 준다. John sets Jane’s salary equal to John’s. 존은 제인의 봉급 동배를 존의 것에 갖다댄다. Jane sets John’s salary equal to Jane’s. 제인은 존의 봉급 동배를 제인의 것에 갖다댄다. The result is that John’s and Jane’s salaries are swapped. Using locking you can prevent this by locking both records. 결과는 존의 것과 제인의 봉급이 바꾸어 지는 것이다.당신을 잠그는 것이 둘 다 기록을 잠금으로써 이것을 막을 수 있는 사용하기. John reads his salary and places a read lock. 존은 그의 봉급과 장소에게 읽기 자물쇠를 읽어 준다. Jane reads her salary and places a read lock. 제인은 그녀의 봉급과 장소에게 읽기 자물쇠를 읽어 준다. John sets Jane’s salary equal to his own but cannot commit due to Jane’s read lock. 존 제인의 봉급 동배를 그의 것에 갖다대지만 제인의 읽기 자물쇠 때문에 범할 수 없다. Jane sets John’s salary equal to her own but cannot commit due to John’s read lock. 제인 존의 봉급 동배를 그녀의 것에 갖다대지만 존의 읽기 자물쇠 때문에 범할 수 없다. Once again you have a deadlock which the database system should resolve by rolling one transaction back. Another solution, using locking, is to write lock the entire table as in the following scenario. 한번 더 당신은 데이터베이스 시스템이 결정해야 하는 교착상태 하나 거래를 취소함으로써을 가지고 있다.다음 시나리오에(서)일 때 자물쇠에게 전체 테이블을 써보내기 위해 잠기고 다른 솔루션 사용하기. John write locks the table. 존 기록은 테이블을 잠근다. John reads his salary. 존은 그의 봉급을 읽는다. Jane tries to read her salary but is blocked by John’s table level write lock. 자물쇠를 써라 제인 그녀의 봉급을 읽으려고 노력하지만 존의 테이블용 레벨에 의하여 막힌다. John sets Jane’s salary equal to his own and releases the write lock. 존이 제인의 봉급 동배를 그의 것에 갖다대고 기록 자물쇠를 발표한다. Jane’s transaction is now free to proceed. 제인의 거래는 지금 자유롭게 계속 나아갈 수 있다. Under versioning: versioning 아래: John reads his own salary. 존은 그의 자신의 봉급을 읽는다. Jane reads her salary. 제인은 그녀의 봉급을 읽는다. John sets Jane’s salary equal to his and commits. 존이 제인의 봉급 동배를 그의 것에 갖다대고 범한다. Jane sets John’s salary equal to hers and commits. 제인이 존의 봉급 동배를 그녀의 것에 갖다대고 범한다. Since versioning allows both transactions to process concurrently once again the salaries are swapped. The only way to solve this problem with the versioning model is as follows. versioning이 두 거래가 동시에 한번 더 줄지어 걷도록 허락하는 이래로 봉급이 바꾸어 진다.versioning 모델을 가지고 이 문제를 해결하기 위한 방법만은 다음과 같다. John reads John’s salary. 존은 존의 봉급에게 읽어 준다. Jane reads Jane’s salary. 제인은 제인의 봉급에게 읽어 준다. John sets Jane’s salary equal to John’s. 존은 제인의 봉급 동배를 존의 것에 갖다댄다. John sets John’s salary to itself creating a newer version. 존은 존의 봉급을 그 자체로 더 새로운 버전을 만드는 것에 갖다댄다. Jane sets John’s salary equal to Jane’s but rolls back because a newer version exists. 제인 존의 봉급 동배를 제인의 것에 갖다대지만 더 새로운 버전이 존재하기 때문에 뒤로 구른다. Here the problem is solved by setting John’s salary equal to itself. This forces the creation of a new record version for John’s salary. Since versioning architecture will not allow a change to be committed when a version of the record to be updated exists which was created after the start of the current transaction Jane’s update rolls back. 여기 문제가 존의 봉급 동배를 갖다댐으로써 그 자체로 해결해 진다.이것은 존의 봉급을 위해 새로운 기록 버전의 창조를 강요한다.업데이트될 기록의 버전이 어느 것이 현재 거래의 시작 후에 만들어 진 존재할 때 versioning 건축이 체인지가 committed을 인정하지 않을 것인 이래로 제인의 업데이트는 취소한다. Recovery 회복 One very important issue in database applications is recovery time if the server crashes. No matter how robust your hardware and software and how reliable your power supply there is always a possibility that the server will fail. Both locking and versioning databases will recover automatically when the server is restarted but there is a significant difference in the time that recovery will take if many transactions are active at the time of the crash. 만약 서버가 부서진다면 데이터베이스 응용 프로그램의 매우 중요한 하나 이슈는 회복 시간이다.당신의 하드웨어와 소프트웨어 비록 어떻게일지라도 얼마나 믿을 수 있는 튼튼하 그리고 당신의 그 곳 파워 서플라이는 언제나 서버가 실패하는 가능성이다.만약 많은 거래가 충돌의 시간에 활발하다면 서버가 재개될 때 잠겨기,versioning 둘 다 데이터베이스가 자동적으로 회복할 것이지만 그 회복이 취할 것인 머지않아 중요한 차이가 있다. Locking model databases write each transaction to a log file. To recover after a crash the database manager must read the log file and rollback all of the transactions that were active at the time of the crash by copying information from the log to the database. 잠기고 있는 모델 데이터베이스는 로그 파일에게 각 거래를 쓴다.충돌 후에 데이터베이스를 되찾기 위해 매니저는 로그 파일과 롤백정책에게 로그로부터 정보를 데이터베이스로 복사함으로써 충돌의 시간에 활발했던 모든 거래를 읽어 주어야 한다. A versioning database does not have a log file. The record versions in the database provide all of the information needed to recover. No data needs to be copied from one place to another. Instead, when the database manager comes back on line it simply scans the transaction inventory pages and changes the status of all active transactions to rolled back. This will take at most a few seconds even with a large number of active transactions. Crash recovery is another area where the versioning model excels. versioning 데이터베이스가 로그 파일을 가지고 있지 않다.데이터베이스의 기록 버전은 회복하는 것이 필요한 모든 정보를 제공한다.데이터는 하나 장소로부터 다른 하나로 복사해 져야 하지 않는다.데이터베이스 매니저가 뒤로 라인 위에서 올 때 그 대신 간단히 그것이 거래 품목일람 페이지를 훑어보고 수많은 활발한 거래 가운데에서 스테이터스를 돌돌 만 백으로바꾼다.이것은 활발한 많은 거래를 가지고 동등하 기껏해야 수초 취할 것이다.versioning 모델이 뛰어난 곳에 충돌 회복은 다른 지역이다. What happens if the one of the disk drives hosting the database has a mechanical failure? With locking model databases you can usually place the log file on a different device and log all transactions since the last database backup. If a physical drive failure occurs you can restore from the last backup and reprocess the log file to recover the database. With a versioning database the only protection against a drive failure is to mirror the database. You can use Interbase’s built in shadowing to accomplish this, use RAID drives or use mirroring at the operating system level. 만약 데이터베이스를 주최하고 있는 디스크 드라이브 중의 하나가 기계적인 실패를 가지고 있다면 무엇이 발생합니까?보통은 당신은 다른 장치와 마지막 데이터베이스 이후 모든 거래 backup 로그 위의 로그 파일을 모델 데이터베이스를 잠그는 것에 제출할 수 있다.만약 육체적 드라이브 실패가 일어난다면 당신이 마지막 백업으로부터 회복할 수 있고 데이터베이스를 되찾기 위해 로그 파일을 재가공 할 수 있다.versioning 데이터베이스를 가지고 드라이브 실패로부터의 보호만은 데이터베이스를 반영하는 것이다.당신 캔 Interbase 사용은 이것을 성취하기 위해 급습 드라이브나 사용을 사용해라 일하고 있는 시스템 레벨에(서)건축업에 종사하는 그늘 지게 하는 반영하 가지고 있다. Expanding the Database 데이터베이스를 늘리기 While some databases require you to shutdown the database to increase the size of the log file and to unload and reload the data to increase the size of the database Interbase does not. Interbase databases expand automatically up to the maximum size allowed by the file system as more data is added. If the database is approaching the maximum size allowed by the operating system more space can be made available by adding a secondary file using the ALTER DATABASE command. While ALTER DATABASE requires exclusive use of the database it is very fast since it does not require the data to be dumped and reloaded. 로그 파일의 사이즈를 증가시키기 위해 당신이 데이터베이스를 폐쇄하는 것 몇몇의 데이터베이스가 데이터를 내리고 데이터베이스의 사이즈를 증가시키기 위해 다시 실으라고 요구하는 동안 Interbase은 하지 않는다.Interbase 데이터베이스는 더 많은 데이터를 더할 때 파일 시스템에 의하여 허락된 최고 사이즈까지 자동적으로 팽창한다.만약 데이터베이스가 운영 체제에 의하여 허락된 최고 사이즈에게 접근하고 있는다면 더 많은 스페이스가 2차은 파일을 더함으로써 데이터베이스 명령을 바꾸어라 사용하는 사용가능하게 만들어 질 수 있다.그것이 데이터에게 떨어지고 다시 실어 지라고 요구하지 않는 이래로 데이터베이스가 그것이 있는 데이터베이스의 배타적인 사용을 매우 빨리 필요로 하게 바뀌어라 While이어라. Other Issues 다른 이슈 At first it might appear that a versioning database has a significant disadvantage because the multiple record versions will cause the database size to increase rapidly compared to a locking database. While that is true do not forget that other databases grow also as their log files expand. 처음에는 다중 기록 버전으로 데이터베이스 사이즈가 잠기고 있는 데이터베이스에 빨리 비유되어서 늘게 될 것이기 때문에 versioning 데이터베이스가 중요한 불이익을 가지고 있는 것처럼 보일 수 있다.그것이 사실인 동안 그들의 로그 파일이 팽창할 때 다른 데이터베이스가 또한 자라는 것을 잊지 말아라. However, versioning databases will certainly grow rapidly if something is not done to control the proliferation of record versions. The database manager performs some of the housekeeping for you automatically. Each time a record is accessed the database manager checks to see if any of the prior versions of that record are no longer needed. A version is no longer needed if its transaction rolled back or if there is a later committed version of the record and there are no active transactions with a transaction number less than the transaction number of the newer committed version. Versions that are no longer needed are automatically deleted and the space they occupied in the database pages is reused. 만약 기록 버전의 확산을 컨트롤하기 위해 뭔가를 하지 않는다면 그러나 물론 versioning 데이터베이스는 빨리 자랄 것이다.데이터베이스 매니저는 당신을 위해 자동적으로 살림살이 중의 일부를 행한다.기록에 접근할 때마다 데이터베이스 매니저는 만약 더 이상 그 기록의 전의 버전 모두가 필요하지 않다면을 보는 것 체크한다.만약 그것의 거래가 취소했다면 만약 기록의 더 최신 committed 버전이 있는다면 더 이상 버전이 필요하지 않고 더 새로운 committed 버전의 거래 숫자가 못 되는 거래 숫자를 가지고 활발한 거래가 없다.자동적으로 더 이상 필요하지 않은 버전을 지우고 그들이 데이터베이스 페이지에(서)차지한 스페이스가 다시 사용된다. Many rows in many databases are visited infrequently. To remove unneeded versions of these rows the database must be swept periodically. A sweep operation visits every row in every table in the database and deletes outdated versions. You can run the sweep while the database is in use but the sweep will impact performance while it is running. 많은 데이터베이스의 많은 줄이 드물게 방문해 진다.이 줄의 unneeded 버전을 제거하기 위해 데이터베이스는 정기적으로 뒤쪽으로 기움에 틀림 없다.쓸기 작동이 데이터베이스의 모든 테이블의 모든 줄을 방문하고 시대에 뒤진 버전을 지운다.그것이 달리고 있는 동안 데이터베이스가 사용중이지만 쓸기가 퍼포먼스에 충격을 줄 것인 동안 당신은 쓸기를 달릴 수 있다. Interbase, by default, will automatically start a sweep after 20,000 transactions. That is not the best way to manage sweeping because you have no control over when the sweep will start and the user that starts the transaction that triggers the sweep is locked until the sweep finishes. It is better to manually start a sweep periodically at a time when database usage is low. Transaction performance is also improved by a sweep performed when no one else is using the database or by a backup and restore. This is because Interbase will not remove record versions older than the Oldest Interesting Transaction (OIT). The OIT is the oldest transaction whose state is something other than committed. The state of all transactions since the OIT is maintained in the TIP and the record versions for these transactions are retained in the database. Performing a sweep when you have exclusive use of the database or performing a backup and restore will reset the OIT to the last committed transaction and remove all prior transactions from the TIP and remove their versions from the database. This not only frees the maximum amount of space in the database but also reduces the size of the TIP. Since the TIP must be copied for each transaction when it starts making the TIP smaller means that transactions will start faster. 부재중의 자동적으로 Interbase은 20,000 거래 후에 쓸기를 시작할 것이다.쓸기가 시작될 것일 때 당신이 쓸기 마무리 억제 수단을 하지 않고 쓸기를 일으키는 거래를 시작하는 사용자가 잠기기 때문에 그것은 청소를 관리하는 가장 좋은 방법이 아니다.데이터베이스 사용이 낮을 때 한번에 손으로 정기적으로 쓸기를 시작하는 것은 더 좋다.또한 거래 퍼포먼스가 그 밖에 아무도 데이터베이스를 사용하지 않고 있을 때 행한 쓸기에 의하여 또는 그리고 복구해라 백업에 의하여 향상된다.이것은 Interbase이 가장 오래된 재미 있는 거래(OIT)보다 더 오래되는 기록 버전을 제거하지 않을 것이기 때문이다.OIT 가장 오래된 거래는 범하여서 누구의 스테이트 뭔가가 달라이 있습니까.수많은 OIT 이후 거래 가운데에서 스테이트가 팁에(서)유지되고 이 거래를위한 기록 버전이 데이터베이스에(서)계속 유지된다.당신이 배타적인 데이터베이스의 사용 백업을 행하는 것을 가지고 있고 복구할 때 쓸기를 행하는 것이 OIT을 다시 마지막 committed 거래로 향하게 할 것이고 팁에서 모든 전의 거래를 제거할 것이고 데이터베이스에서 그들의 버전을 제거할 것이다.이것 단지 데이터베이스의 최고 상당량의 스페이스를 자유롭게 해 주지 않지만 또한 팁의 사이즈를 줄인다.그것이 시작될 때 팁이 각 거래를 위해 카피되어야 하는 이래로 팁을 더 작게 만드는 것은 거래가 더 빨리 시작될 것을 의미한다. Interbase has a very small footprint requiring less than 10 megabytes of disk space and is very easy to install and configure. There are only two parameters you need to set. The first is the page size of the database and the second is the cache size in pages. Once these parameters are set Interbase tunes itself to provide optimum performance. Easy installation and maintenance make Interbase a good choice for installations where there is no database administrator. Finally, Interbase runs on a wide variety of platforms which makes it easily scalable to handle changing needs. Interbase이 매우 작은 발자국 디스크 공간의 미만 메가바이트 10 개을 필요로 하는 것을 가지고 있고 설치하고 만들기에 매우 쉽다.당신이 놓아야 하는 파라미터 2 편만이 있다.첫째가 데이터베이스의 페이지 사이즈이고 두 번째는 페이지의 은닉처 사이즈이다.일단 이 파라미터가 놓아 지면 Interbase은 최적인 퍼포먼스를 제공하는 것 그 자체를 조화시킨다.데이터베이스 관리자가 없는 곳에 쉬운 설치와 유지보수는 설비를 위해 Interbase을 좋은 선택으로 만든다.마침내 Interbase은 변하고 있는 필요한 것을 다루는 것을 쉽게 저울로 달 수 있게 하는 넓은 다양한 플랫폼 위에서 달린다. Interbase also supports multiple character sets per table making it an ideal choice for international applications. Interbase pioneered efficient storage of BLOB data and supports multiple BLOB fields per database as well as updateable views. 또한 Interbase은 국제적인 응용 프로그램을 위해 그것을 이상적인 선택으로 만들고 있는 테이블당 다중 문자 세트를 지지한다.Interbase이 얼룩 데이터의 능률적인 저장을 개척했고 updateable 뷰 뿐만 아니라 데이터베이스당 다중 얼룩 필드를 지지한다. Conclusion 결말 Selecting the right database for your application requires a clear understanding of the types of transactions the system will have to process. Many applications today include a mixture of multi-row read transactions and updates. In this environment versioning has a clear advantage because it can process read and write transactions concurrently while still providing serializable isolation to ensure accuracy. Versioning also provides very rapid crash recovery since there is no log file to process. When a versioning database restarts it simply marks all open but uncommitted transactions as rolled back and is ready to go. 당신의 응용을 위한 옳은 데이터베이스를 선택하는 것은 유형의 시스템이 처리해야 할 것인 거래의 명확한 이해를 필요로 한다.많은 오늘 응용 프로그램은 multi-row 읽기 거래와 업데이트의 혼합을 포함한다.그것이 줄지어 걸을 수 있기 때문에 아직도 정확성을 확실하게 하기 위해 serializable 고립을 제공하는 동안 이 환경에(서)versioning은 명확한 이점이 거래를 읽고 동시에 쓰게 한다.로그 파일이 없는 이래로 또한 Versioning은 줄지어 걷기 위해 매우 빠른 충돌 회복을 제공한다.versioning 데이터베이스가 재개할 때 취소했고 갈 준비가 되어 있을 때 간단히 그것은 열려 있지만 저지르지 않 모든 거래에 자국을 낸다. At this writing Inprise’s Interbase is both the newest of the major database servers and the only one to use the versioning model. In addition to the advantages of the versioning model Interbase has the smallest disk and memory footprint (it ships on two diskettes), is self tuning and runs on Netware, Windows NT and a wide variety of Unix platforms so it is highly scalable. 이 글에(서)Inprise의 Interbase은 주요한 데이터베이스 서버 중에 가장 새로운 versioning 모델을 사용할 유일한 하나 둘 다이다.versioning 모델의 이점 외에 Interbase이 디스크와 메모리 가장 작은 발자국을 가지고 있고(그것이 디스켓 2 자루 위에서 배를 타는 것)이다.자기 튜닝과 런은 Netware와 Windows NT와 넓은 다양한 Unix 플랫폼 위에서 있다 그래서 그것이 저울로 달 수 있 대단히이다. -------------------------------------------------------------------------------- Add or View comments on this article 이 물품 위의 코멘트를 더하여라 그렇지 않으면 보아라 Products: Products: InterBase 3.x, InterBase 4.x, InterBase 5.0, InterBase 5.1, InterBase 5.2, InterBase 5.5, InterBase 5.6, InterBase 6.0 InterBase 3.x,InterBase 4.x,InterBase 5.0,InterBase 5.1,InterBase 5.2,InterBase 5.5,InterBase 5.6,InterBase 6.0 Article ID: 23216 Publish Date: September 21, 2000 Last Modified: October 27, 2000 ID 물품:23216은 날짜를 출판한다:2000 년 9 월 21 일은 부분 수정되어서 계속된다:2000 년 10 월 27 일